import API from '@/api/index.js';
import { setToken, removeToken, checkProfileCompleteness } from '@/utils/auth.js';
import { SocialTypeEnum, getSocialTypeValues } from '@/utils/constants.js';

const state = {
  // 用户信息
  userInfo: null,
  // 是否已登录
  isLogin: false,
  // token信息
  token: null,
  // 刷新token
  refreshToken: null,
  // 过期时间
  expiresTime: 0,
  // 资料引导是否被跳过
  profileGuideSkipped: false
};

const mutations = {
  // 设置用户登录状态
  SET_LOGIN_STATUS(state, status) {
    state.isLogin = status;
  },

  // 设置用户信息
  SET_USER_INFO(state, info) {
    // 将后端返回的vip字段映射为前端使用的isVip字段
    if(info) {
      // 确保字段一致性，将vip映射到isVip
      info.isVip = info.vip !== undefined ? info.vip : info.isVip;

      // 处理会员过期时间
      if (info.vipExpireTime) {
        info.vipExpireText = formatVipExpireText(info.vipExpireTime);
      }
    }

    state.userInfo = info;
  },

  // 设置token信息
  SET_TOKEN_INFO(state, tokenInfo) {
    if (tokenInfo) {
      const { accessToken, refreshToken, expiresTime } = tokenInfo;
      state.token = accessToken;
      state.refreshToken = refreshToken;
      state.expiresTime = expiresTime;
    } else {
      state.token = null;
      state.refreshToken = null;
      state.expiresTime = 0;
    }
  },

  // 清除用户信息
  CLEAR_USER_INFO(state) {
    state.userInfo = null;
    state.isLogin = false;
    state.token = null;
    state.refreshToken = null;
    state.expiresTime = 0;
  },

  // 设置资料引导跳过状态
  SET_PROFILE_GUIDE_SKIPPED(state, skipped) {
    state.profileGuideSkipped = skipped;
  }
};

const actions = {
  // 微信小程序登录(带手机号)
  async wxMiniAppLogin({ commit, dispatch }, loginData) {
    try {
      console.log('开始微信小程序登录(带手机号)...');
      const result = await API.user.weixinMiniAppLogin(loginData);
      console.log('微信小程序登录返回结果:', JSON.stringify(result));

      // 保存token信息
      const tokenData = result.data || result;
      console.log('准备保存的token数据:', JSON.stringify(tokenData));
      commit('SET_TOKEN_INFO', tokenData);

      // 设置登录状态
      commit('SET_LOGIN_STATUS', true);

      // 将token存储到本地
      setToken(tokenData);

      // 保存openid到本地存储，如果存在的话
      if (result.data && result.data.openid) {
        console.log('从result.data中获取到openid:', result.data.openid);
        uni.setStorageSync('openid', result.data.openid);
        console.log('openid已保存到本地存储');
      } else if (result.openid) {
        console.log('从result根对象中获取到openid:', result.openid);
        uni.setStorageSync('openid', result.openid);
        console.log('openid已保存到本地存储');
      } else {
        console.warn('登录返回数据中没有找到openid');
      }

      // 验证openid是否成功保存
      const savedOpenid = uni.getStorageSync('openid');
      console.log('保存后从存储中读取的openid:', savedOpenid);

      // 保存userId到本地存储，如果存在的话
      if (result.data && result.data.userId) {
        uni.setStorageSync('userId', result.data.userId);
      } else if (result.data && result.data.id) {
        uni.setStorageSync('userId', result.data.id);
      } else if (result.userId) {
        uni.setStorageSync('userId', result.userId);
      } else if (result.id) {
        uni.setStorageSync('userId', result.id);
      }

      // 触发登录成功回调
      dispatch('handleLoginSuccess');

      return tokenData;
    } catch (error) {
      console.error('微信小程序登录失败:', error);
      return Promise.reject(error);
    }
  },

  // 微信小程序登录(无需手机号)
  async wxMiniAppSimpleLogin({ commit, dispatch }, loginData) {
    try {
      const result = await API.user.weixinMiniAppSimpleLogin(loginData);
      // 保存token信息
      commit('SET_TOKEN_INFO', result.data || result);
      // 设置登录状态
      commit('SET_LOGIN_STATUS', true);
      // 将token存储到本地
      setToken(result.data || result);

      // 保存openid到本地存储，如果存在的话
      if (result.data && result.data.openid) {
        uni.setStorageSync('openid', result.data.openid);
      }

      // 验证openid是否成功保存
      const savedOpenid = uni.getStorageSync('openid');
      console.log('保存后从存储中读取的openid:', savedOpenid);

      // 保存userId到本地存储，如果存在的话
      if (result.data && result.data.userId) {
        uni.setStorageSync('userId', result.data.userId);
      } else if (result.data && result.data.id) {
        uni.setStorageSync('userId', result.data.id);
      } else if (result.userId) {
        uni.setStorageSync('userId', result.userId);
      } else if (result.id) {
        uni.setStorageSync('userId', result.id);
      }

      // 触发登录成功回调
      dispatch('handleLoginSuccess');

      return result.data || result;
    } catch (error) {
      console.error('微信小程序简易登录失败:', error);
      return Promise.reject(error);
    }
  },

  // 社交登录
  async socialLogin({ commit, dispatch }, loginData) {
    try {
      console.log('开始社交登录...', loginData);
      // 确保loginData中的type值在合法的范围内
      // 使用枚举中定义的类型值
      const validTypes = getSocialTypeValues();
      if (!validTypes.includes(loginData.type)) {
        return Promise.reject(new Error(`社交登录类型无效，必须是以下值之一: ${validTypes.join(', ')}`));
      }

      // 记录场景值，如果有的话
      if (loginData.scene) {
        console.log('社交登录包含场景值:', loginData.scene);
      }

      const result = await API.user.socialLogin(loginData);
      console.log('社交登录返回结果:', JSON.stringify(result));

      // 保存token信息
      const tokenData = result.data || result;
      console.log('准备保存的token数据:', JSON.stringify(tokenData));
      commit('SET_TOKEN_INFO', tokenData);

      // 设置登录状态
      commit('SET_LOGIN_STATUS', true);

      // 将token存储到本地
      setToken(tokenData);

      // 保存openid到本地存储，如果存在的话
      if (result.data && result.data.openid) {
        console.log('从result.data中获取到openid:', result.data.openid);
        uni.setStorageSync('openid', result.data.openid);
        console.log('openid已保存到本地存储');
      } else if (result.openid) {
        console.log('从result根对象中获取到openid:', result.openid);
        uni.setStorageSync('openid', result.openid);
        console.log('openid已保存到本地存储');
      } else {
        console.warn('登录返回数据中没有找到openid');
      }

      // 验证openid是否成功保存
      const savedOpenid = uni.getStorageSync('openid');
      console.log('保存后从存储中读取的openid:', savedOpenid);

      // 保存userId到本地存储，如果存在的话
      if (result.data && result.data.userId) {
        uni.setStorageSync('userId', result.data.userId);
      } else if (result.data && result.data.id) {
        uni.setStorageSync('userId', result.data.id);
      } else if (result.userId) {
        uni.setStorageSync('userId', result.userId);
      } else if (result.id) {
        uni.setStorageSync('userId', result.id);
      }

      // 触发登录成功回调
      dispatch('handleLoginSuccess');

      return tokenData;
    } catch (error) {
      console.error('社交登录失败:', error);
      return Promise.reject(error);
    }
  },

  // 获取用户信息
  async getUserInfo({ commit }) {
    try {
      const result = await API.user.getUserInfo();

      const userInfo = result;

      // 更新用户信息到store
      commit('SET_USER_INFO', userInfo);

      // 添加：确保设置登录状态为true
      commit('SET_LOGIN_STATUS', true);

      // 如果用户信息中包含openid，则保存到本地存储
      if (userInfo && userInfo.openid) {
        uni.setStorageSync('openid', userInfo.openid);
      }

      // 保存userId到本地存储，用于WebSocket连接
      if (userInfo && userInfo.id) {
        uni.setStorageSync('userId', userInfo.id);
      } else if (userInfo && userInfo.userId) {
        uni.setStorageSync('userId', userInfo.userId);
      }

      // 检查资料引导跳过状态
      const skippedTime = uni.getStorageSync('profile_guide_skipped');
      const now = Date.now();
      const isSkipped = skippedTime && (now - skippedTime < 24 * 60 * 60 * 1000);
      commit('SET_PROFILE_GUIDE_SKIPPED', isSkipped);

      return userInfo;
    } catch (error) {
      console.error('获取用户信息失败:', error);
      return Promise.reject(error);
    }
  },

  // 刷新token
  async refreshToken({ commit }, refreshToken) {
    try {
      const result = await API.user.refreshToken(refreshToken);
      // 更新token信息
      commit('SET_TOKEN_INFO', result);
      // 将token存储到本地
      setToken(result);
      return result;
    } catch (error) {
      console.error('刷新token失败:', error);
      return Promise.reject(error);
    }
  },

  // 退出登录
  async logout({ commit }) {
    try {
      await API.user.logout();
    } catch (error) {
      console.error('退出登录失败:', error);
    } finally {
      // 无论退出是否成功，都清除本地登录状态
      commit('CLEAR_USER_INFO');
      // 移除本地存储的token
      removeToken();
    }
  },

  // 更新用户资料 (仅管理员使用)
  async updateUserProfile({ commit, dispatch }, profileData) {
    try {
      console.log('更新用户资料:', profileData);

      // 调用更新资料API (仅限管理员使用，普通用户应使用submitUserProfileForAudit)
      const result = await API.user.updateUserProfile(profileData);

      // 更新成功后，重新获取用户信息以确保数据一致性
      await dispatch('getUserInfo');

      // 更新资料完整度状态
      const profileStatus = checkProfileCompleteness(state.userInfo);
      uni.setStorageSync('profile_status', profileStatus);

      return result;
    } catch (error) {
      console.error('更新用户资料失败:', error);
      return Promise.reject(error);
    }
  },

  // 提交用户资料审核
  async submitUserProfileForAudit({ commit, dispatch }, profileData) {
    try {
      console.log('提交用户资料审核:', profileData);

      // 调用提交审核API
      const result = await API.user.submitProfileForAudit(profileData);

      // 更新成功后，重新获取用户信息以确保数据一致性
      await dispatch('getUserInfo');

      // 更新资料完整度状态
      const profileStatus = checkProfileCompleteness(state.userInfo);
      uni.setStorageSync('profile_status', profileStatus);

      return result;
    } catch (error) {
      console.error('提交用户资料审核失败:', error);
      return Promise.reject(error);
    }
  },

  // 获取用户资料审核状态
  async getProfileAuditStatus() {
    try {
      return await API.user.getProfileAuditStatus();
    } catch (error) {
      console.error('获取用户资料审核状态失败:', error);
      return Promise.reject(error);
    }
  },

  // 处理登录成功后的回调
  handleLoginSuccess({ commit, dispatch }) {
    // 触发app模块的登录回调
    dispatch('app/executeLoginCallbacks', null, { root: true });
  },

  // 处理跳过资料引导
  skipProfileGuide({ commit }) {
    // 记录用户跳过，24小时内不再提示
    uni.setStorageSync('profile_guide_skipped', Date.now());
    // 更新状态
    commit('SET_PROFILE_GUIDE_SKIPPED', true);
  },
  
  // 添加新方法：强制检查资料完整度并根据需要重置引导弹窗状态
  forceCheckProfileCompleteness({ commit, getters }) {
    // 获取当前资料完整度
    const { completionPercentage } = getters.profileStatus;
    
    // 如果资料完成度低于阈值，重置跳过状态，强制显示引导
    if (completionPercentage < 60) {
      // 清除本地存储中的跳过记录
      uni.removeStorageSync('profile_guide_skipped');
      // 重置Vuex中的跳过状态
      commit('SET_PROFILE_GUIDE_SKIPPED', false);
      // 返回false表示资料不完整
      return false;
    }
    
    // 返回true表示资料已完整
    return true;
  }
};

const getters = {
  // 计算用户资料完整度
  profileStatus: (state) => {
    if (!state.userInfo) {
      return {
        isComplete: false,
        completionPercentage: 100,
        isCoreComplete: false,
        missingFields: ['全部资料']
      };
    }
    
    // 使用工具函数检查资料完整度
    return checkProfileCompleteness(state.userInfo);
  },
  
  // 是否应该显示资料引导
  shouldShowProfileGuide: (state, getters) => {
    // 如果未登录，不显示
    if (!state.isLogin) return false;
    
    // 如果当前已标记为跳过，直接返回false
    if (state.profileGuideSkipped) return false;
    
    const { isCoreComplete, completionPercentage } = getters.profileStatus;
    
    // 目前不启用强制引导
    // if (!isCoreComplete) return true;
    
    // 资料完成度低于阈值(60%)，检查是否在24小时内跳过
    if (completionPercentage < 60) {
      const skippedTime = uni.getStorageSync('profile_guide_skipped');
      const now = Date.now();
      
      // 未跳过或跳过超过24小时
      return !skippedTime || (now - skippedTime > 24 * 60 * 60 * 1000);
    }
    
    return false;
  }
};

export default {
  namespaced: true,
  state,
  mutations,
  actions,
  getters
};

/**
 * 格式化会员过期时间文本
 * @param {String} expireTime - 过期时间字符串
 * @returns {String} 格式化后的文本
 */
function formatVipExpireText(expireTime) {
  if (!expireTime) return '';

  const expireDate = new Date(expireTime);
  const now = new Date();

  // 计算剩余天数
  const diffTime = expireDate.getTime() - now.getTime();
  const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));

  if (diffDays <= 0) {
    return '已过期';
  } else if (diffDays === 1) {
    return '今日到期';
  } else {
    return `剩余${diffDays}天`;
  }
}
